#include<iostream>
#include<algorithm>
#include<string>
#include<vector>
using namespace std;
struct student
{
    string _name;
    int _score;
};


//快排总结：
//三种方法都无法解决序列有序时快排退化的问题，但三路划分可以解决重复元素过多的退化问题
//因为萝卜坑和霍尔的方法相同元素一次只能确定一个元素的位置，而三路划分一次把相同元素位置全部确定
void quicksort_pit(struct student* v,int begin,int end)
{
    if(begin>=end) return ;
    int left=begin,right=end;
    
    while(left<right)
    {
    	while(left<right)
    	{
    		if(v[right]._score>=v[left]._score)
    		{
    			right--;
			}
			else
			{
				break;
			}
		}
		
		swap(v[left],v[right]);

		while(left<right)
		{
			if(v[left]._score<=v[right]._score)
    		{
    			left++;
			}
			else
			{
				break;
			}
		}

		swap(v[left],v[right]);


    }
    quicksort_pit(v,begin,left-1);
    quicksort_pit(v,left+1,end); 
} 


void quicksort_hoare(struct student* v,int begin,int end)
{
    if(begin>=end) return ;
    int left=begin,right=end;
    //选取左边元素作为key，最后交换时应该是一个小于key的值，所以右先走，这样left和right相等时就是了
    int key=v[begin]._score;
    while(left<right)
    {
    	while(left<right)
    	{
    		if(v[right]._score>=key)
    		{
    			right--;
			}
			else
			{
				break;
			}
		}
		while(left<right)
		{
			if(v[left]._score<=key)
    		{
    			left++;
			}
			else
			{
				break;
			}
		}
		if(left<right)
		{
			swap(v[left],v[right]);
		}
		else
		{
			swap(v[left],v[begin]);
			
		}
    }
    quicksort_hoare(v,begin,left-1);
    quicksort_hoare(v,left+1,end); 
} 




void quicksort_three_divide(struct student* v,int begin,int end)
{
    if(begin>=end) return ;
    int left=begin,right=end,i=begin;
    int key=v[begin]._score;
    while(i<=end)
    {
    
        if(v[i]._score<key)
        {
            swap(v[i],v[right]);
            right--;
        }
        else if(v[i]._score>key)
        {
            swap(v[i],v[left]);
            i++;
            left++;
        }
        else
        {
            i++;
        }
    }
    quicksort_three_divide(v,begin,left-1);
    quicksort_three_divide(v,right+1,end);
    
    
} 

void mergesort(student* v,int begin,int end)
{
    if(begin>=end) return ;
    int mid=(begin+end)/2;//两个要分成一个，一个要结束递归开始合并，如果是【begin，mid-1】 【mid，end】就会两个时死递归
    mergesort(v,begin,mid); 
    mergesort(v,mid+1,end);
    int tmp1=begin,tmp2=mid+1;
    int arr[50];
    int t=begin;
    while(tmp1<=mid &&tmp2<=end)
    {
        if(v[tmp1]._score>=v[tmp2]._score)
        {
            arr[t++]=v[tmp1++]._score;
            
            
        }
        else
        {
            arr[t++]=v[tmp2++]._score;
        }
        
    }
    while(tmp1<=mid)
    {
        arr[t++]=v[tmp1++]._score;
    }
        while(tmp2<=end)
    {
            arr[t++]=v[tmp2++]._score;
    }
    for(int j=begin;j<=end;j++)
    {
        v[j]._score=arr[j];
    }
    
    
    
}

void bubblesort(struct student* v,int n)
{
    for(int i=0;i<n-1;i++)
    {
        for(int j=i+1;j<n;j++)
        {
            if(v[i]._score<v[j]._score)
            {
                swap(v[i],v[j]);
            }
        }
    }
    
    
} 
int main()
{
    struct student v[100];
    int i=0; 
    while(1)
    {
        cin>>v[i]._name>>v[i]._score;
        if(v[i]._name=="0" &&v[i]._score==0)
        {
            break;
        }
        i++;
    }
    //cout<<i;
    //i个数据 
    quicksort_pit(v,0,i-1);
    //mergesort(v,0,i-1);
    //bubblesort(v,i);
	//bubblesort(v,i);

    for(int j=0;j<i;j++)
    {
        cout<<j+1<<" "<<v[j]._name<<" "<<v[j]._score<<endl; 
    }
    
    
    
    
    return 0;
}